package com.zmm.util.time;

import com.zmm.common.constant.RegularConstant;
import com.zmm.common.enums.DatePatternEnums;
import com.zmm.common.exception.handle.BusinessException;
import com.zmm.util.convert.StringUtil;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.DayOfWeek;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.prefs.BackingStoreException;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @author 900045
 * @description:
 * @name DateUtil
 * @date By 2021-06-22 11:33:02
 */
public final class DateUtil {

	private static Logger logger        = LoggerFactory.getLogger(DateUtil.class);
	/**
	 * 日期时分秒
	 */

	public static final String SF = "\\d{4}-\\d{1,2}-\\d{1,2}\\s\\d{2}:\\d{2}:\\d{2}";

	/**
	 * 日期时分
	 */
	public static final String SFM = "\\d{4}-\\d{1,2}-\\d{1,2}\\s\\d{2}:\\d{2}";

	/** yyyy-MM-dd */
	public static final String SF1 = "yyyy-MM-dd";
	/** yyyy-MM-dd HH:mm */
	public static final String SFM2 = "yyyy-MM-dd HH:mm";
	/** yyyy-MM-dd HH:mm:ss */
	public static final String SF3 = "yyyy-MM-dd HH:mm:ss";

	public static final String SF2 = "yyyyMMddHH";

	public static final String SF4 = "yyyy-MM";
	
	public static final String SF5 = "yyyyMM";


	public DateUtil() {
	}

	public static String getNowDateHH() {
		return ThreadDateUtil.getDateFormat(SF2).format(new Date());
	}

	/**
	 * 获取当前时间 格式 yyyy-MM-dd HH:mm:ss
	 * @author: 900045
	 * @date: 2021-07-05 15:50:53
	 * @throws 
	 * @return: java.lang.String
	 **/
	public static String getNow() {
		return ThreadDateUtil.getDateFormat(SF3).format(new Date());
	}

	public static String getNow(String format) {
		return ThreadDateUtil.getDateFormat(format).format(new Date());
	}

	public static int getDateToWeek(String datetime, String format) {
		int w = LocalDate.parse(datetime, DateTimeFormatter.ofPattern(format)).getDayOfWeek()
				.getValue();
		return w;
	}

	public static String getMonday() {
		//获取当前时间
		LocalDate local = LocalDate.now();
		//获取今天是周几
		DayOfWeek dayOfWeek = local.getDayOfWeek();
		//算出本周一
		LocalDate monday = local.minusDays(dayOfWeek.getValue() - 1);
		return monday.toString();
	}

	/**
	 * 获得当前时间second秒后的时间戳
	 * @param second
	 * @return
	 */
	public static long getCurrentTimeInMillis(int second) {
		Calendar cal = Calendar.getInstance();
		if (second > 0) {
			cal.add(Calendar.SECOND, second);
		}
		return cal.getTimeInMillis();
	}

	/**
	 * 获取指定时间的在一周内第几天的日期
	 * @param timestamp
	 * @param format
	 * @param index 一周内的第几天，从周一开始，周日结束，1起始
	 * @return
	 */
	public static String getThisWeekDay(long timestamp, String format, int index) {
		Instant instant = Instant.ofEpochMilli(timestamp);
		ZoneId zone = ZoneId.systemDefault();
		//获取当前时间
		LocalDateTime localDateTime = LocalDateTime.ofInstant(instant, zone);
		//获取今天是周几
		DayOfWeek dayOfWeek = localDateTime.getDayOfWeek();
		//算出本周一
		LocalDateTime monday = localDateTime.minusDays(dayOfWeek.getValue() - index);
		DateTimeFormatter formatter = DateTimeFormatter.ofPattern(format);
		return monday.format(formatter);
	}

	public static String getSunday() {
		//获取当前时间
		LocalDate local = LocalDate.now();
		//获取今天是周几
		DayOfWeek dayOfWeek = local.getDayOfWeek();
		//算出本周日
		LocalDate monday = local.minusDays(dayOfWeek.getValue() - 7);
		return monday.toString();
	}

	public static long getTimeStamp(String dateStr, String format){
		try {
			SimpleDateFormat sdf = new SimpleDateFormat(format);
			Date date = sdf.parse(dateStr);
			return date.getTime();
		}catch (Exception e){
			return 0;
		}


	}

	/**
	 * 格式是 yyyy-MM-dd
	 * @author: 900045
	 * @date: 2021-07-26 16:55:19
	 * @throws 
	
	 * @return: java.lang.String
	 **/
	public static String getNowDate() {
		return ThreadDateUtil.getDateFormat(SF1).format(new Date());
	}

	/**
	 * 格式是 yyyy-MM-dd HH:mm
	 * @author: 900045
	 * @date: 2021-07-26 16:55:32
	 * @throws 
	
	 * @return: java.lang.String
	 **/
	public static String getNowDateSFM() {
		return ThreadDateUtil.getDateFormat(SFM2).format(new Date());
	}

	public static Date getNowDate(String format) {
		SimpleDateFormat sdf = new SimpleDateFormat(format);
		try {
			return sdf.parse(sdf.format(new Date()));
		} catch (ParseException e) {
			logger.error(e.getMessage(), e);
			return null;
		}
	}

	/**
	 * 获取上一个小时时间
	 *  yyyyMMddHH
	 * @param date
	 * @return
	 */
	public static Long getPreHour(Date date) {
		Calendar calendar = Calendar.getInstance();
		SimpleDateFormat sdf = new SimpleDateFormat(SF2);
		try {
			Date formatDate = sdf.parse(sdf.format(date));
			formatDate.getHours();
			calendar.setTime(formatDate);
			calendar.add(Calendar.HOUR, -1);
		} catch (ParseException e) {
			logger.error(e.getMessage(), e);
			return null;
		}
		return calendar.getTime().getTime();
	}

	/**
	 * 获取下一个小时时间
	 *  yyyyMMddHH
	 * @param date
	 * @return
	 */
	public static Long getNextHour(Date date) {
		Calendar calendar = Calendar.getInstance();
		SimpleDateFormat sdf = new SimpleDateFormat(SF2);
		try {
			Date formatDate = sdf.parse(sdf.format(date));
			calendar.setTime(formatDate);
			calendar.add(Calendar.HOUR, 1);
		} catch (ParseException e) {
			logger.error(e.getMessage(), e);
			return null;
		}
		return calendar.getTime().getTime();
	}

	/**
	 * 获取前一天的起始时间
	 *  yyyyMMddHH
	 * @param date
	 * @return
	 */
	public static String getPreDayStartHH(Date date) {
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		calendar.add(Calendar.DATE, -1);
		calendar.set(Calendar.HOUR_OF_DAY, 0);
		calendar.set(Calendar.MINUTE, 0);
		calendar.set(Calendar.SECOND, 0);
		date = calendar.getTime();
		return ThreadDateUtil.getDateFormat(SF2).format(date);
	}

	/**
	 * 获取前一天的结束时间
	 *  yyyyMMddHH
	 * @param date
	 * @return
	 */
	public static String getPreDayEndHH(Date date) {
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		calendar.add(Calendar.DATE, -1);
		calendar.set(Calendar.HOUR_OF_DAY, 23);
		calendar.set(Calendar.MINUTE, 59);
		calendar.set(Calendar.SECOND, 59);
		date = calendar.getTime();
		return ThreadDateUtil.getDateFormat(SF2).format(date);
	}

	/**
	 * 根据时间类型比较时间大小 
	 *
	 * @param source
	 * @param target
	 * @return
	 *  0 ：source和 target 时间相同    
	 *  1 ：source比 target 时间大  
	 *  -1：source比 target 时间小
	 * @throws Exception
	 */
	public static int DateCompare(long source, long target) throws Exception {
		if (source == target)
			return 0;
		else if (source > target) {
			return 1;
		} else {
			return -1;
		}
	}

	/**
	 * 方法名: getTime
	 * 方法描述: 获取当前时间时分
	 * 修改时间：2016年12月2日 上午10:12:46 
	 * 参数 @return 参数说明
	 * 返回类型 String 返回类型
	 */
	public static String getTime(long time) {
		return ThreadDateUtil.getDateFormat("HH:mm").format(time);
	}

	/**
	 * 方法名: getTime
	 * 方法描述: 获取当前时间时分
	 * 修改时间：2016年12月2日 上午10:12:46 
	 * 参数 @return 参数说明
	 * 返回类型 String 返回类型
	 */
	public static String getTime() {
		return ThreadDateUtil.getDateFormat("HH:mm").format(getNowTime());
	}

	/**
	 * 方法名: getEndTime
	 * 方法描述: (这里用一句话描述这个方法的作用)
	 * 修改时间：2016年11月24日 下午9:17:18 
	 * 参数 @param date
	 * 参数 @return 参数说明
	 * 返回类型 Date 返回类型
	 */
	public static Date getEndTime(Date date) {
		if (date == null) {
			return null;
		}
		Calendar calendar = getCalendar();
		calendar.setTime(date);
		return calendar.getTime();
	}



	/**
	 * 方法名: getDate
	 * 方法描述: 将long型的时间 字符串 转换为yyyy-MM-dd格式的日期字符串
	 * 修改时间：2017年6月19日 下午3:24:45 
	 * 参数 @param str
	 * 参数 @return 参数说明
	 * 返回类型 String 返回类型
	 */
	public static String getDate(String str) {
		Date d = new Date(StringUtil.parseLong(str));
		return ThreadDateUtil.getDateFormat(SF1).format(d);
	}

	public static Integer getRemainSecondsOneDay(Date currentDate) {
		LocalDateTime midnight = LocalDateTime
				.ofInstant(currentDate.toInstant(), ZoneId.systemDefault()).plusDays(1).withHour(0)
				.withMinute(0).withSecond(0).withNano(0);
		LocalDateTime currentDateTime = LocalDateTime.ofInstant(currentDate.toInstant(),
				ZoneId.systemDefault());
		long seconds = ChronoUnit.SECONDS.between(currentDateTime, midnight);
		return (int) seconds;
	}


	/**
	 * 方法名: getDate
	 * 方法描述: long 转date
	 * 修改时间：2017年6月13日 上午10:50:34 
	 * 参数 @param dateTime
	 * 参数 @return 参数说明
	 * 返回类型 Date 返回类型
	 */
	public static Date getDate(long dateTime) {
		String date = getDateTime(dateTime);
		Date d = null;
		try {
			d = ThreadDateUtil.getDateFormat(SF3).parse(date);
			return d;
		} catch (ParseException e) {
			logger.error("", e);
		}
		return null;
	}

	/**
	 * 方法名: getDateByLong
	 * 方法描述: long 转成String YYYY-MM-dd
	 * 修改时间：2017年6月13日 上午11:41:43 
	 * 参数 @param dateTime
	 * 参数 @return 参数说明
	 * 返回类型 String 返回类型
	 */
	public static String getDateByLong(long dateTime) {
		Date date = getDate(dateTime);
		return ThreadDateUtil.getDateFormat(SF1).format(date);
	}

	public static String getDateTime(Long date) {
		return getDateTime(date, SF3);
	}

	public static String getDateTime(Long date, String format) {
		if (null == date) {
			return "";
		}
		try {
			Date d = new Date(date);
			return ThreadDateUtil.getDateFormat(format).format(d);
		} catch (Exception e) {
			logger.error(" getTime E: {}", date, e);
		}
		return "";
	}

    /*@Deprecated 请使用 getDateTime(Long date, String format)
    public static String getTime(Long date) {
        if (null == date) {
            return "";
        }
        try {
            Date d = new Date(date);
            return ThreadDateUtil.getDateFormat(SF3).format(d);
        } catch (Exception e) {
            logger.error(" getTime E: {}", date, e);
        }
        return "";
    }*/

	/**
	 * 方法名: getStartTime
	 * 方法描述: 获取当前0点
	 * 修改时间：2017年5月8日 下午5:03:49 
	 * 参数 @return 参数说明
	 * 返回类型 Long 返回类型
	 */
	public static long getStartTime() {
		Calendar todayStart = getCalendar0();
		return todayStart.getTime().getTime();
	}

	/**
	 * 方法名: getEndTime
	 * 方法描述: 获取当天结束时间
	 * 修改时间：2017年5月8日 下午5:04:12 
	 * 参数 @return 参数说明
	 * 返回类型 long 返回类型
	 */
	public static long getEndTime() {
		Calendar todayEnd = getCalendar();
		return todayEnd.getTime().getTime();
	}

	/**
	 * 方法名: getStartTime
	 * 方法描述: 获取当前0点
	 * 修改时间：2017年5月8日 下午5:03:49 
	 * 参数 @return 参数说明
	 * 返回类型 Long 返回类型
	 * @throws ParseException
	 */
	public static long getStartTime(String dateStr) throws ParseException {
		if (StringUtils.isBlank(dateStr)) {
			return 0;
		} else {
			Date date = ThreadDateUtil.getDateFormat(SF1).parse(dateStr);
			Calendar cal = getCalendar0();
			cal.setTime(date);
			return cal.getTime().getTime();
		}

	}

	/**
	 * 方法名: getEndTime
	 * 方法描述: 获取当天结束时间
	 * 修改时间：2017年5月8日 下午5:04:12 
	 * 参数 @return 参数说明
	 * 返回类型 long 返回类型
	 * @throws ParseException
	 */
	public static long getEndTime(String dateStr) throws ParseException {
		if (StringUtils.isBlank(dateStr)) {
			return 0;
		} else {
			Date date = ThreadDateUtil.getDateFormat(SF1).parse(dateStr);
			Calendar calendar = Calendar.getInstance();
			calendar.setTime(date);
			calendar.set(Calendar.HOUR_OF_DAY, 23);
			calendar.set(Calendar.MINUTE, 59);
			calendar.set(Calendar.SECOND, 59);
			calendar.set(Calendar.MILLISECOND, 999);
			return calendar.getTime().getTime();
		}
	}

	/**
	 *   获取 指定时间毫秒数的0点
	 *
	 * @param time
	 * @return
	 */
	public static long getStartTime(long time) {
		Calendar cal = getCalendar0();
		cal.setTimeInMillis(time);
		return cal.getTime().getTime();
	}

	/**
	 *   获取 指定时间毫秒数的23点59分59秒999毫秒
	 *
	 * @param time
	 * @return
	 */
	public static long getEndTime(long time) {
		Calendar todayEnd = getCalendar();
		todayEnd.setTimeInMillis(time);
		return todayEnd.getTime().getTime();
	}

	/**
	 * 获取当前时间的前一天
	 * @return
	 */
	public static long getPreDayTimestamp() {
		//得到一个Calendar的实例
		Calendar ca = Calendar.getInstance();
		//设置时间为当前时间
		ca.setTime(new Date());
		ca.add(Calendar.DATE, -1);
		//结果
		Date lastDay = ca.getTime();
		return lastDay.getTime();
	}

	public static String getDatem(Long date) {
		try {
			Date d = new Date(date);
			return ThreadDateUtil.getDateFormat(SFM2).format(d);
		} catch (Exception e) {
			logger.error(" getDatem E: {}", date, e);
		}
		return "";
	}

	/**
	 * 获取当前时间戳  yyyy-MM-dd HH:mm:ss
	 * @author: 900045
	 * @date: 2021-07-26 17:14:56
	 * @throws 
	 * @return: java.lang.Long
	 **/
	public static Long getNowTime() {
		return System.currentTimeMillis();
	}

	/**
	 * 获取上周在一年中的星期周期序号。
	 * @return
	 */
	public static int getLastWeek() {

		Calendar cal = Calendar.getInstance();
		cal.setTime(getThisWeekMonday(new Date()));
		cal.add(Calendar.DATE, -7);

		return cal.get(Calendar.WEEK_OF_YEAR);
	}

	public static Date getThisWeekMonday(Date date) {
		Calendar cal = Calendar.getInstance();
		cal.setTime(date);
		// 获得当前日期是一个星期的第几天
		int dayWeek = cal.get(Calendar.DAY_OF_WEEK);
		if (1 == dayWeek) {
			cal.add(Calendar.DAY_OF_MONTH, -1);
		}
		// 设置一个星期的第一天，按中国的习惯一个星期的第一天是星期一
		cal.setFirstDayOfWeek(Calendar.MONDAY);
		// 获得当前日期是一个星期的第几天
		int day = cal.get(Calendar.DAY_OF_WEEK);
		// 根据日历的规则，给当前日期减去星期几与一个星期第一天的差值
		cal.add(Calendar.DATE, cal.getFirstDayOfWeek() - day);
		return cal.getTime();
	}

	/**
	 * 获取上周星期一的日期
	 * @param format
	 * @return
	 */
	public static String getLastWeekMonday(String format) {
		Calendar cal = Calendar.getInstance();
		cal.setTime(getThisWeekMonday(new Date()));
		cal.add(Calendar.DATE, -7);
		return format(cal.getTime(), format);
	}

	public static String getLastWeekSunday(String format) {

		Calendar cal = Calendar.getInstance();
		cal.setTime(getThisWeekMonday(new Date()));
		cal.add(Calendar.DATE, -1);
		return format(cal.getTime(), format);
	}

	/**
	 * 方法名: getTodayEndTime
	 * 方法描述: 获取当天结束时间
	 * 修改时间：2016年11月2日 下午6:53:23 
	 * 参数 @return 参数说明
	 * 返回类型 Long 返回类型
	 */
	public static int getDiffTodayEndTime() {
		return (int) ((getTodayEndTime() - getNowTime()) / 1000);
	}

	/**
	 * 方法名: getStartDateTime
	 * 方法描述: 获取一天开始time
	 * 修改时间：2016年12月5日 上午11:57:01 
	 * 参数 @param time
	 * 参数 @return 参数说明
	 * 返回类型 String 返回类型
	 */
	public static String getStartDateTime(long time) {
		Date d = new Date(time);
		return ThreadDateUtil.getDateFormat(SF3).format(d);
	}

	public static String getStartDateTime(long time, String format) {
		Date d = new Date(time);
		return ThreadDateUtil.getDateFormat(format).format(d);
	}

	/**
	 * 方法名: getTodayEndTime
	 * 方法描述: 获取当天时间差
	 * 修改时间：2016年11月2日 下午6:53:23 
	 * 参数 @return 参数说明
	 * 返回类型 Long 返回类型
	 */
	public static Long getTodayEndTime() {
		Calendar todayEnd = getCalendar();
		return todayEnd.getTime().getTime();
	}

	public static Long getLongTime(String str) {
		if (StringUtils.isBlank(str)) {
			return getNowTime();
		}
		Date date = null;
		try {
			if (str.matches(SF)) {
				date = ThreadDateUtil.getDateFormat(SF3).parse(str);
			} else if (str.matches(SFM)) {
				date = ThreadDateUtil.getDateFormat(SFM2).parse(str);
			} else {
				date = ThreadDateUtil.getDateFormat(SF1).parse(str);
			}
		} catch (ParseException e) {
			logger.error(" getLongTime E: {}", str, e);
		}
		if (null == date) {
			return 0L;
		}
		return date.getTime();

	}

	/**
	 *  把时间参数 转换为 long
	 *
	 * @param dateStr
	 * @return
	 * @throws BackingStoreException
	 */
	public static long getTime(String dateStr) throws BusinessException {
		try {
			Date date = ThreadDateUtil.getDateFormat(SF3).parse(dateStr);
			return date.getTime();
		} catch (ParseException e) {
			logger.error(" getTime E: {}", dateStr, e);
			throw new BusinessException(" time parese error: " + dateStr);
		}
	}

	/**
	 * 方法名: getNowYear
	 * 方法描述: 获取当前年份
	 * 修改时间：2016年6月22日 下午6:52:24 
	 * 参数 @return 参数说明
	 * 返回类型 String 返回类型
	 */
	public static String getNowYear() {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy");
		Date date = new Date();
		return sdf.format(date);
	}

	/**
	 * 方法名: getFormatTime
	 * 方法描述: 转化为所需要的格式日期
	 * 修改时间：2017年10月25日 上午11:56:18 
	 * 参数 @param str
	 * 参数 @return 参数说明
	 * 返回类型 String 返回类型
	 */
	public static String getFormatTime(String str) {
		if (StringUtils.isBlank(str)) {
			return null;
		}
		SimpleDateFormat sdf = new SimpleDateFormat(str);
		Date date = new Date();
		return sdf.format(date);

	}

	/**
	 * 方法名: getNowMonth
	 * 方法描述: 获取当前年月yyyy/MM
	 * 修改时间：2016年6月22日 下午6:52:24 
	 * 参数 @return 参数说明
	 * 返回类型 String 返回类型
	 */
	public static String getNowMonth() {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM");
		Date date = new Date();
		return sdf.format(date);
	}

	/**
	 * 方法名: getNowMonth
	 * 方法描述: 获取当前年月
	 * 修改时间：2019年3月25日
	 * 参数 @return 参数说明
	 * 返回类型 String 返回类型
	 */
	public static String getNowMonth(String format) {
		SimpleDateFormat sdf = new SimpleDateFormat(format);
		Date date = new Date();
		return sdf.format(date);
	}

	/**
	 * 方法名: getNowYearMonthDay
	 * 方法描述: 获取当前年月yyyy/MM/dd
	 * 修改时间：2017年6月28日 上午10:52:24 
	 * 参数 @return 参数说明
	 * 返回类型 String 返回类型
	 */
	public static String getNowYearMonthDay() {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
		Date date = new Date();
		return sdf.format(date);
	}

	/**
	 * 方法名: getNowMonthDaySn
	 * 方法描述: 获取当前年月yyyyMMdd
	 * 修改时间：2017年6月28日 上午10:52:24 
	 * 参数 @return 参数说明
	 * 返回类型 String 返回类型
	 */
	public static String getNowMonthDay() {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
		Date date = new Date();
		return sdf.format(date);
	}

	/**
	 * dq
	 * 获取指定年月yyyyMMddHHmmss
	 * @param dateTime
	 * @return
	 */
	public static String getNowMonthDay(long dateTime) {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss");
		Date date = new Date(dateTime);
		return sdf.format(date);
	}

	public static String getAge(String birthDate) {
		if (null == birthDate) {
			throw new RuntimeException("出生日期不能为null");
		}

		int age = 0;
		String[] str = birthDate.split("-");
		if (str.length == 3) {
			Date now = new Date();
			SimpleDateFormat format_y = new SimpleDateFormat("yyyy");
			SimpleDateFormat format_M = new SimpleDateFormat("MM");
			String birth_year = str[0];
			String this_year = format_y.format(now);
			String birth_month = str[1];
			String this_month = format_M.format(now);
			// 初步，估算
			age = Integer.parseInt(this_year) - Integer.parseInt(birth_year);

			// 如果未到出生月份，则age - 1

			if (this_month.compareTo(birth_month) < 0){
				age -= 1;}
			if (age < 0){
				age = 0;}
			return age + "." + (StringUtil.parseInt(this_month) - StringUtil.parseInt(this_month));
		}

		return "0";
	}

	public static String getPreDay(Date date) {
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		calendar.add(Calendar.DAY_OF_MONTH, -1);
		date = calendar.getTime();
		return ThreadDateUtil.getDateFormat(SF1).format(date);
	}

	/**
	 * 方法名: isBirthday
	 * 方法描述: 判断输入的字符串是否是合法的生日 生日不能大于当前日期
	 * 修改时间：2017年3月22日 上午9:16:09 
	 * 参数 @param birthday
	 * 参数 @return 参数说明
	 * 返回类型 boolean 返回类型
	 */
	public static boolean isBirthday(String birthday) {
		if (StringUtils.isBlank(birthday)) {
			return false;
		}
		if (birthday.length() != 10) {
			return false;
		}
		Pattern pattern = Pattern.compile(RegularConstant.BIRTHDAY_REGEX);
		Matcher matcher = pattern.matcher(birthday);
		if (!matcher.matches()) {
			return false;
		}
		Date birth = null;
		try {
			birth = new SimpleDateFormat("yyyy-MM-dd").parse(birthday);
		} catch (ParseException e) {
			logger.error("", e);
		}
		if (!new SimpleDateFormat("yyyy-MM-dd").format(birth).equals(birthday)) {
			return false;
		}
		// 获取当前日期的毫秒数
		long currentTime = System.currentTimeMillis();
		// 获取生日的毫秒数
		long birthTime = birth.getTime();
		// 如果当前时间小于生日，生日不合法。反之合法
		if (birthTime > currentTime) {
			return false;
		}
		return true;
	}

	/**
	 * 方法名: isAfterHour
	 * 方法描述: 当前时间7点之后可以显示
	 * 修改时间：2017年5月11日 下午3:39:34 
	 * 参数 @return 参数说明
	 * 返回类型 boolean 返回类型
	 */
	public static boolean isAfterHour() {
		Calendar todayStart = Calendar.getInstance();
		//用d.getHour()可以获取当前小时数。
		int hour = todayStart.get(Calendar.HOUR_OF_DAY);
		return hour >= 7;
	}

	/**wye
	 * 获取某天开始时间0:0:0:0
	 *
	 * @param date
	 * @param addDay
	 * @return
	 */
	public static long getStartTime(Date date, int addDay) {
		Calendar dayTimeStart = getCalendar0();
		if (addDay != 0) {
			dayTimeStart.add(Calendar.DATE, addDay);
		}
		dayTimeStart.setTime(date);
		return dayTimeStart.getTime().getTime();

	}

	/**wye
	 * 获取某天结束时间23:59:59:999
	 *
	 * @param date
	 * @param addDay
	 * @return
	 */
	public static long getEndTime(Date date, int addDay) {
		Calendar dayTimeEnd = getCalendar();
		dayTimeEnd.setTime(date);
		if (addDay != 0) {
			dayTimeEnd.add(Calendar.DATE, addDay);
		}
		return dayTimeEnd.getTime().getTime();
	}

	/**
	 * wye
	 * 获取当前时间 之后或之前的几天
	 * @param dateTime
	 * @return
	 * @throws ParseException
	 */
	public static long getLongTimeByDay(long dateTime, int day) {
		Calendar start = Calendar.getInstance();
		start.setTimeInMillis(dateTime);
		start.add(Calendar.DAY_OF_MONTH, day);
		return start.getTime().getTime();
	}

	/**
	 * 方法名: getTimeForMessage
	 * 方法描述: 夺宝消息列表显示中奖时间
	 * 修改时间：2017年8月2日 下午12:39:13 
	 * 参数 @param timeMinute 分钟
	 * 参数 @return 参数说明  天or时or 分
	 * 返回类型 int 返回类型
	 */
	public static String getTimeForMessage(long timeMinute) {
		int day = (int) (timeMinute / (24 * 60));
		int hour = (int) ((timeMinute % (24 * 60)) / 60);
		int minute = (int) ((timeMinute % (24 * 60)) % 60);
		if (day > 0) {
			return day + "天";
		} else if (hour > 0) {
			return hour + "小时";
		} else {
			minute = minute == 0 ? 1 : minute;
			return minute + "分钟";
		}

	}

	/**
	 *  日期格式化字符串
	 *     默认格式   yyyy-MM-dd HH:mm:ss
	 */
	public static String format(Date date) {
		if (date == null) {
			return null;
		}
		return format(date, DatePatternEnums.YYYY_MM_DD_HH_MM_SS);
	}

	/**
	 *  日期格式化字符串
	 */
	public static String format(Date date, DatePatternEnums datePattern) {
		if (date == null || datePattern == null) {
			return null;
		}
		return format(date, datePattern.pattern);
	}

	/**
	 * 日期格式化字符串
	 *
	 * @param date    日期对象
	 * @param pattern   日期格式
	 * @return
	 */
	public static String format(Date date, String pattern) {
		if (date == null) {
			return null;
		}
		return ThreadDateUtil.getDateFormat(pattern).format(date);
	}


	public static String format2(Date date, String pattern) {
		if(date != null){
			SimpleDateFormat df = new SimpleDateFormat(pattern);
			return df.format(date);
		}
		return null;
	}

	/**
	 *   日期字符串  转换为日期
	 *     默认格式   yyyy-MM-dd HH:mm:ss
	 * @throws ParseException
	 */
	public static Date parse(String source) throws ParseException {
		return parse(source, DatePatternEnums.YYYY_MM_DD_HH_MM_SS);
	}

	/**
	 * 日期格式化字符串
	 *
	 * @param source               时间字符串
	 * @param datePattern    日期格式
	 * @return
	 * @throws ParseException
	 */
	public static Date parse(String source, DatePatternEnums datePattern) throws ParseException {
		return parse(source, datePattern.pattern);
	}

	/**
	 *    日期字符串  转换为日期
	 *
	 * @param source    时间字符串
	 * @param pattern  日期格式
	 * @return
	 * @throws ParseException
	 */
	public static Date parse(String source, String pattern) throws ParseException {
		return ThreadDateUtil.getDateFormat(pattern).parse(source);
	}

	/**
	 *   日期字符串  转换为日期毫秒数
	 *    默认格式   yyyy-MM-dd HH:mm:ss
	 * @throws ParseException
	 */
	public static Long parseToLong(String source) throws ParseException {
		return parse(source, DatePatternEnums.YYYY_MM_DD_HH_MM_SS).getTime();
	}

	/**
	 * 日期字符串  转换为日期毫秒数
	 *
	 * @param source               时间字符串
	 * @param datePattern    日期格式
	 * @return
	 * @throws ParseException
	 */
	public static Long parseToLong(String source, DatePatternEnums datePattern) throws ParseException {
		return parse(source, datePattern.pattern).getTime();
	}

	/**
	 *    日期字符串  转换为日期毫秒数
	 *
	 * @param source    时间字符串
	 * @param pattern  日期格式
	 * @return
	 * @throws ParseException
	 */
	public static Long parseToLong(String source, String pattern) throws ParseException {
		return ThreadDateUtil.getDateFormat(pattern).parse(source).getTime();
	}

	/**
	 * 功能描述：返回小时
	 *
	 * @param date
	 *            日期
	 * @return 返回小时
	 */
	public static int getHour(Date date) {
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		return calendar.get(Calendar.HOUR_OF_DAY);
	}

	/**
	 * 获取日期的部分
	 * @param date
	 * @param part YEAR = 1 MONTH = 2 DATE = 5
	 * @return
	 */
	public static int getDatePart(Date date, int part) {
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		return calendar.get(part);
	}

	/**
	 * 获取加几月的日期
	 * @param date
	 * @param month
	 */
	public static Date addMonth(Date date, int month) {
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		calendar.add(Calendar.MONTH, month);
		return calendar.getTime();
	}

	/**
	 * 获取某月的最后一天
	 * @param year
	 * @param month 0~11
	 * @return
	 */
	public static String getLastDayOfMonth(int year, int month) {
		return getFirstOrLastDayOfMonth(year,month,1);
	}

	/**
	 * 抽取 getLastDayOfMonth / getFirstDayOfMonth
	 * @author: 900045
	 * @date: 2021-03-11 17:50:09
	 * @throws
	 * @param year: 
	 * @param month: 
	 * @param type: 
	 * @return: java.lang.String
	 **/
	public static String getFirstOrLastDayOfMonth(int year, int month,int type){
		Calendar cal = Calendar.getInstance();
		//设置年份
		cal.set(Calendar.YEAR, year);
		//设置月份
		cal.set(Calendar.MONTH, month);
		switch (type){
			case 1:
				//获取某月最大天数
				int lastDay = cal.getActualMaximum(Calendar.DAY_OF_MONTH);
				//设置日历中月份的最大天数
				cal.set(Calendar.DAY_OF_MONTH, lastDay);
				break;
			case 2:
				//获取某月最小天数
				int firstDay = cal.getMinimum(Calendar.DAY_OF_MONTH);
				//设置日历中月份的最大天数
				cal.set(Calendar.DAY_OF_MONTH, firstDay);
				break;
			default:
		}
		//格式化日期
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		String firstDayOfMonth = sdf.format(cal.getTime());

		return firstDayOfMonth;
	}

	/**
	 *获取某月的最开始一天
	 * @param year
	 * @param month 0~11
	 * @return
	 */
	public static String getFirstDayOfMonth(int year, int month) {

		return getFirstOrLastDayOfMonth(year,month,2);
	}
	/**
	 * 获取某年某周的日历
	 * @param year
	 * @param week
	 * @return
	 */
	public static Calendar getCalendar(int year,int week) {
		Calendar cal = Calendar.getInstance();
		//设置年份
		cal.set(Calendar.YEAR,year);
		//设置周
		cal.set(Calendar.WEEK_OF_YEAR, week);
		//设置该周第一天为星期一
		cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
		return cal;
	}
	/**
	 * 获取当前日历，每周第一天为 星期一
	 * @return
	 */
	public static Calendar getThisCalendar() {
		Calendar cal = Calendar.getInstance();
		//设置该周第一天为星期一
		cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
		return cal;
	}
	/**
	 * 获取周一为一周开始，周日为一周结算，
	 * 获取当前时间所在一年中的周数
	 * @return
	 */
	public static int getweekNumOfYear() {
		Calendar cal = Calendar.getInstance();
		//设置该周第一天为星期一
		cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
		cal.setFirstDayOfWeek(Calendar.MONDAY);
		return cal.get(Calendar.WEEK_OF_YEAR);
	}
	/**
	 * 获取某年某周的第一天（星期一）
	 * @param year
	 * @param week
	 * @return
	 */
	public static String getFirstDayOfWeek(int year,int week) {
		Calendar cal = getCalendar(year, week);
		//格式化日期
		SimpleDateFormat sdf = new SimpleDateFormat(SF1);
		String date = sdf.format(cal.getTime());

		return date;
	}
	/**
	 * 获取某年某周的最后一天（星期日）
	 * @param year
	 * @param week
	 * @return
	 */
	public static String getLastDayOfWeek(int year,int week) {
		Calendar cal = getCalendar(year, week);
		cal.add(Calendar.DATE, 6);
		//格式化日期
		SimpleDateFormat sdf = new SimpleDateFormat(SF1);
		String date = sdf.format(cal.getTime());

		return date;
	}

	/**
	 * 计算剩余时间，创建时间+有效时长-当前时间。
	 * @param createTime
	 * @param seconds
	 * @return
	 */
	public static long getRemainSecond(Long createTime, Long seconds) {
		long i = 0L;
		try {
			i = createTime-System.currentTimeMillis()/1000+seconds;
		}catch(Exception e) {
			logger.info("获取剩余时间异常，默认为0。createTime {}, seconds {}", createTime, seconds);
		}
		return i;
	}

	/**
	 * 计算剩余时间，结束时间-当前时间。
	 * @param endTime
	 * @return
	 */
	public static long getRemainSecond(Long endTime) {
		long i = 0L;
		try {
			i = endTime-System.currentTimeMillis()/1000;
		}catch(Exception e) {
			logger.info("获取剩余时间异常，默认为0。endTime {}", endTime);
		}
		return i;
	}

	/**
	 * 计算给定时间一年后的时间戳
	 */
	public static Long getNextYear(Long time){
		// 取时间
		Date date = new Date(time);
		Calendar calendar = Calendar.getInstance();
		SimpleDateFormat sdf = new SimpleDateFormat(SF2);
		try {
			Date formatDate = sdf.parse(sdf.format(date));
			calendar.setTime(formatDate);
			calendar.add(Calendar.YEAR, 1);
		} catch (ParseException e) {
			logger.error(e.getMessage(), e);
			return null;
		}
		return getStartTime(calendar.getTime().getTime());
	}


	/**
	 * 获取当月开始时间戳
	 */
	public static long getMinDateForMonth() {
		Calendar calendar = getCalendar0();
		calendar.setTime(new Date());
		calendar.set(Calendar.DAY_OF_MONTH, calendar.getActualMinimum(Calendar.DAY_OF_MONTH));
		return calendar.getTime().getTime();
	}

	/**
	 * 获取当月结束时间戳
	 */
	public static long getMaxDateForMonth() {
		Calendar calendar2 = getCalendar();
		calendar2.setTime(new Date());
		calendar2.set(Calendar.DAY_OF_MONTH, calendar2.getActualMaximum(Calendar.DAY_OF_MONTH));
		return calendar2.getTime().getTime();
	}


	/**
	 * 获得 Calendar
	 * @author: 900045
	 * @date: 2021-03-11 17:38:08
	 * @throws
	 * @return: java.util.Calendar
	 **/
	private static Calendar getCalendar() {
		Calendar calendar = Calendar.getInstance();
		calendar.set(Calendar.HOUR_OF_DAY, 23);
		calendar.set(Calendar.MINUTE, 59);
		calendar.set(Calendar.SECOND, 59);
		calendar.set(Calendar.MILLISECOND, 999);
		return calendar;
	}

	private static Calendar getCalendar0() {
		Calendar todayStart = Calendar.getInstance();
		todayStart.set(Calendar.HOUR_OF_DAY, 0);
		todayStart.set(Calendar.MINUTE, 0);
		todayStart.set(Calendar.SECOND, 0);
		todayStart.set(Calendar.MILLISECOND, 0);
		return todayStart;
	}


	/**
	 * 系统时间加减，自定义日期格式
	 * DateUtil.getOperaDate("2019-02-27 09:54:31", "日",5, "yyyy-MM-dd HH:mm:ss")
	 * @author: 900045
	 * @date: 2021-09-07 10:49:14
	 * @throws
	 * @param date: 
	 * @param type: 
	 * @param Num: 
	 * @param formatStr: 
	 * @return: java.lang.String
	 **/
	public static String getOperaDate(String date, String type, Integer Num, String formatStr) {
		Date dt = null;
		SimpleDateFormat df = new SimpleDateFormat(formatStr);
		try {
			dt = df.parse(date);
		} catch (ParseException e) {
			e.printStackTrace();
		}
		GregorianCalendar gc = new GregorianCalendar();
		assert dt != null;
		gc.setTime(dt);
		switch (type){
			case "日":
				gc.add(Calendar.DATE,Num);
				break;
			case "月":
				gc.add(Calendar.MONTH, Num);
				break;
			case "季度":
				gc.add(Calendar.MONTH, Num * 3);
				break;
			case "年":
				gc.add(Calendar.YEAR, Num);
				break;
		}
		return df.format(gc.getTime());
	}


	/**
	 * 比较日期的大小，yyyy-mm-dd DATE1>=DATE2,返回true
	 * @author: 900045
	 * @date: 2021-10-09 15:25:21
	 * @throws 
	 * @param date1: 
	 * @param date2: 
	 * @return: boolean
	 **/
	public static boolean compareDate(String date1, String date2) {
		//初始返回值
		boolean f=false;
		try {
			DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
			Date dt1 = df.parse(date1);
			Date dt2 = df.parse(date2);
			//dt1在dt2后
			if (dt1.getTime() >= dt2.getTime()) {
				f=true;
			}
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return f;
	}

}
